Micrografx ABC Graphics Suite/Micrografx ABC Graphics Suite - Disc 2.iso/abc.z/ABCAUTO.CPP

C/C++ Source or Header | 1995-09-15 | 90KB | 4,515 lines

// Machine generated IDispatch driver class(es) created with ClassWizard.

#include "stdafx.h"
#include "abcauto.h"


/////////////////////////////////////////////////////////////////////////////
// Application properties

LPDISPATCH Application::GetActiveChart()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

void Application::SetActiveChart(LPDISPATCH propVal)
{
    SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH Application::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x2, VT_DISPATCH, (void*)&result);
    return result;
}

void Application::SetApplication(LPDISPATCH propVal)
{
    SetProperty(0x2, VT_DISPATCH, propVal);
}

long Application::GetBottom()
{
    long result;
    GetProperty(0x3, VT_I4, (void*)&result);
    return result;
}

void Application::SetBottom(long propVal)
{
    SetProperty(0x3, VT_I4, propVal);
}

CString Application::GetCaption()
{
    CString result;
    GetProperty(0x4, VT_BSTR, (void*)&result);
    return result;
}

void Application::SetCaption(const char* propVal)
{
    SetProperty(0x4, VT_BSTR, propVal);
}

LPDISPATCH Application::GetCharts()
{
    LPDISPATCH result;
    GetProperty(0x5, VT_DISPATCH, (void*)&result);
    return result;
}

void Application::SetCharts(LPDISPATCH propVal)
{
    SetProperty(0x5, VT_DISPATCH, propVal);
}

CString Application::GetDefaultFilePath()
{
    CString result;
    GetProperty(0x6, VT_BSTR, (void*)&result);
    return result;
}

void Application::SetDefaultFilePath(const char* propVal)
{
    SetProperty(0x6, VT_BSTR, propVal);
}

BOOL Application::GetFieldViewerVisible()
{
    BOOL result;
    GetProperty(0x7, VT_BOOL, (void*)&result);
    return result;
}

void Application::SetFieldViewerVisible(BOOL propVal)
{
    SetProperty(0x7, VT_BOOL, propVal);
}

long Application::GetFieldViewerWindowHandle()
{
    long result;
    GetProperty(0x8, VT_I4, (void*)&result);
    return result;
}

void Application::SetFieldViewerWindowHandle(long propVal)
{
    SetProperty(0x8, VT_I4, propVal);
}

CString Application::GetFullName()
{
    CString result;
    GetProperty(0x9, VT_BSTR, (void*)&result);
    return result;
}

void Application::SetFullName(const char* propVal)
{
    SetProperty(0x9, VT_BSTR, propVal);
}

long Application::GetHeight()
{
    long result;
    GetProperty(0xa, VT_I4, (void*)&result);
    return result;
}

void Application::SetHeight(long propVal)
{
    SetProperty(0xa, VT_I4, propVal);
}

BOOL Application::GetHourglass()
{
    BOOL result;
    GetProperty(0xb, VT_BOOL, (void*)&result);
    return result;
}

void Application::SetHourglass(BOOL propVal)
{
    SetProperty(0xb, VT_BOOL, propVal);
}

BOOL Application::GetIndexVisible()
{
    BOOL result;
    GetProperty(0xc, VT_BOOL, (void*)&result);
    return result;
}

void Application::SetIndexVisible(BOOL propVal)
{
    SetProperty(0xc, VT_BOOL, propVal);
}

long Application::GetIndexWindowHandle()
{
    long result;
    GetProperty(0xd, VT_I4, (void*)&result);
    return result;
}

void Application::SetIndexWindowHandle(long propVal)
{
    SetProperty(0xd, VT_I4, propVal);
}

long Application::GetLeft()
{
    long result;
    GetProperty(0xe, VT_I4, (void*)&result);
    return result;
}

void Application::SetLeft(long propVal)
{
    SetProperty(0xe, VT_I4, propVal);
}

CString Application::GetName()
{
    CString result;
    GetProperty(0xf, VT_BSTR, (void*)&result);
    return result;
}

void Application::SetName(const char* propVal)
{
    SetProperty(0xf, VT_BSTR, propVal);
}

BOOL Application::GetNoteViewerVisible()
{
    BOOL result;
    GetProperty(0x10, VT_BOOL, (void*)&result);
    return result;
}

void Application::SetNoteViewerVisible(BOOL propVal)
{
    SetProperty(0x10, VT_BOOL, propVal);
}

long Application::GetNoteViewerWindowHandle()
{
    long result;
    GetProperty(0x11, VT_I4, (void*)&result);
    return result;
}

void Application::SetNoteViewerWindowHandle(long propVal)
{
    SetProperty(0x11, VT_I4, propVal);
}

CString Application::GetOperatingSystem()
{
    CString result;
    GetProperty(0x12, VT_BSTR, (void*)&result);
    return result;
}

void Application::SetOperatingSystem(const char* propVal)
{
    SetProperty(0x12, VT_BSTR, propVal);
}

LPDISPATCH Application::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x13, VT_DISPATCH, (void*)&result);
    return result;
}

void Application::SetParent(LPDISPATCH propVal)
{
    SetProperty(0x13, VT_DISPATCH, propVal);
}

CString Application::GetPath()
{
    CString result;
    GetProperty(0x14, VT_BSTR, (void*)&result);
    return result;
}

void Application::SetPath(const char* propVal)
{
    SetProperty(0x14, VT_BSTR, propVal);
}

short Application::GetPercentGaugeValue()
{
    short result;
    GetProperty(0x15, VT_I2, (void*)&result);
    return result;
}

void Application::SetPercentGaugeValue(short propVal)
{
    SetProperty(0x15, VT_I2, propVal);
}

LPDISPATCH Application::GetPreferences()
{
    LPDISPATCH result;
    GetProperty(0x16, VT_DISPATCH, (void*)&result);
    return result;
}

void Application::SetPreferences(LPDISPATCH propVal)
{
    SetProperty(0x16, VT_DISPATCH, propVal);
}

CString Application::GetPrinter()
{
    CString result;
    GetProperty(0x17, VT_BSTR, (void*)&result);
    return result;
}

void Application::SetPrinter(const char* propVal)
{
    SetProperty(0x17, VT_BSTR, propVal);
}

long Application::GetRight()
{
    long result;
    GetProperty(0x18, VT_I4, (void*)&result);
    return result;
}

void Application::SetRight(long propVal)
{
    SetProperty(0x18, VT_I4, propVal);
}

BOOL Application::GetShapePaletteVisible()
{
    BOOL result;
    GetProperty(0x19, VT_BOOL, (void*)&result);
    return result;
}

void Application::SetShapePaletteVisible(BOOL propVal)
{
    SetProperty(0x19, VT_BOOL, propVal);
}

long Application::GetShapePaletteWindowHandle()
{
    long result;
    GetProperty(0x1a, VT_I4, (void*)&result);
    return result;
}

void Application::SetShapePaletteWindowHandle(long propVal)
{
    SetProperty(0x1a, VT_I4, propVal);
}

CString Application::GetStatusBar()
{
    CString result;
    GetProperty(0x1b, VT_BSTR, (void*)&result);
    return result;
}

void Application::SetStatusBar(const char* propVal)
{
    SetProperty(0x1b, VT_BSTR, propVal);
}

long Application::GetTop()
{
    long result;
    GetProperty(0x1c, VT_I4, (void*)&result);
    return result;
}

void Application::SetTop(long propVal)
{
    SetProperty(0x1c, VT_I4, propVal);
}

BOOL Application::GetUndoAvailable()
{
    BOOL result;
    GetProperty(0x1d, VT_BOOL, (void*)&result);
    return result;
}

void Application::SetUndoAvailable(BOOL propVal)
{
    SetProperty(0x1d, VT_BOOL, propVal);
}

CString Application::GetVersion()
{
    CString result;
    GetProperty(0x1e, VT_BSTR, (void*)&result);
    return result;
}

void Application::SetVersion(const char* propVal)
{
    SetProperty(0x1e, VT_BSTR, propVal);
}

BOOL Application::GetVisible()
{
    BOOL result;
    GetProperty(0x1f, VT_BOOL, (void*)&result);
    return result;
}

void Application::SetVisible(BOOL propVal)
{
    SetProperty(0x1f, VT_BOOL, propVal);
}

long Application::GetWidth()
{
    long result;
    GetProperty(0x20, VT_I4, (void*)&result);
    return result;
}

void Application::SetWidth(long propVal)
{
    SetProperty(0x20, VT_I4, propVal);
}

long Application::GetWindowHandle()
{
    long result;
    GetProperty(0x21, VT_I4, (void*)&result);
    return result;
}

void Application::SetWindowHandle(long propVal)
{
    SetProperty(0x21, VT_I4, propVal);
}

long Application::GetWhite()
{
    long result;
    GetProperty(0x22, VT_I4, (void*)&result);
    return result;
}

void Application::SetWhite(long propVal)
{
    SetProperty(0x22, VT_I4, propVal);
}

long Application::GetBlack()
{
    long result;
    GetProperty(0x23, VT_I4, (void*)&result);
    return result;
}

void Application::SetBlack(long propVal)
{
    SetProperty(0x23, VT_I4, propVal);
}

long Application::GetRed()
{
    long result;
    GetProperty(0x24, VT_I4, (void*)&result);
    return result;
}

void Application::SetRed(long propVal)
{
    SetProperty(0x24, VT_I4, propVal);
}

long Application::GetGreen()
{
    long result;
    GetProperty(0x25, VT_I4, (void*)&result);
    return result;
}

void Application::SetGreen(long propVal)
{
    SetProperty(0x25, VT_I4, propVal);
}

long Application::GetBlue()
{
    long result;
    GetProperty(0x26, VT_I4, (void*)&result);
    return result;
}

void Application::SetBlue(long propVal)
{
    SetProperty(0x26, VT_I4, propVal);
}

long Application::GetYellow()
{
    long result;
    GetProperty(0x27, VT_I4, (void*)&result);
    return result;
}

void Application::SetYellow(long propVal)
{
    SetProperty(0x27, VT_I4, propVal);
}

long Application::GetMagenta()
{
    long result;
    GetProperty(0x28, VT_I4, (void*)&result);
    return result;
}

void Application::SetMagenta(long propVal)
{
    SetProperty(0x28, VT_I4, propVal);
}

long Application::GetCyan()
{
    long result;
    GetProperty(0x29, VT_I4, (void*)&result);
    return result;
}

void Application::SetCyan(long propVal)
{
    SetProperty(0x29, VT_I4, propVal);
}

long Application::GetGray()
{
    long result;
    GetProperty(0x2a, VT_I4, (void*)&result);
    return result;
}

void Application::SetGray(long propVal)
{
    SetProperty(0x2a, VT_I4, propVal);
}

long Application::GetDk_red()
{
    long result;
    GetProperty(0x2b, VT_I4, (void*)&result);
    return result;
}

void Application::SetDk_red(long propVal)
{
    SetProperty(0x2b, VT_I4, propVal);
}

long Application::GetDk_green()
{
    long result;
    GetProperty(0x2c, VT_I4, (void*)&result);
    return result;
}

void Application::SetDk_green(long propVal)
{
    SetProperty(0x2c, VT_I4, propVal);
}

long Application::GetDk_blue()
{
    long result;
    GetProperty(0x2d, VT_I4, (void*)&result);
    return result;
}

void Application::SetDk_blue(long propVal)
{
    SetProperty(0x2d, VT_I4, propVal);
}

long Application::GetDk_yellow()
{
    long result;
    GetProperty(0x2e, VT_I4, (void*)&result);
    return result;
}

void Application::SetDk_yellow(long propVal)
{
    SetProperty(0x2e, VT_I4, propVal);
}

long Application::GetDk_magenta()
{
    long result;
    GetProperty(0x2f, VT_I4, (void*)&result);
    return result;
}

void Application::SetDk_magenta(long propVal)
{
    SetProperty(0x2f, VT_I4, propVal);
}

long Application::GetDk_cyan()
{
    long result;
    GetProperty(0x30, VT_I4, (void*)&result);
    return result;
}

void Application::SetDk_cyan(long propVal)
{
    SetProperty(0x30, VT_I4, propVal);
}

long Application::GetDk_gray()
{
    long result;
    GetProperty(0x31, VT_I4, (void*)&result);
    return result;
}

void Application::SetDk_gray(long propVal)
{
    SetProperty(0x31, VT_I4, propVal);
}

BOOL Application::GetStatusBarVisible()
{
    BOOL result;
    GetProperty(0x32, VT_BOOL, (void*)&result);
    return result;
}

void Application::SetStatusBarVisible(BOOL propVal)
{
    SetProperty(0x32, VT_BOOL, propVal);
}

BOOL Application::GetZoomWindowVisible()
{
    BOOL result;
    GetProperty(0x33, VT_BOOL, (void*)&result);
    return result;
}

void Application::SetZoomWindowVisible(BOOL propVal)
{
    SetProperty(0x33, VT_BOOL, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// Application operations

void Application::Activate()
{
    InvokeHelper(0x34, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Application::ArrangeIcons()
{
    InvokeHelper(0x35, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

long Application::BasicColor(short Color)
{
    long result;
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x36, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
        Color);
    return result;
}

void Application::CascadeCharts()
{
    InvokeHelper(0x37, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Application::ChartTypeShutdown(const char* ChartType, const char* ApplicationName)
{
    static BYTE BASED_CODE parms[] =
        VTS_BSTR VTS_BSTR;
    InvokeHelper(0x38, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         ChartType, ApplicationName);
}

void Application::CloseAll()
{
    InvokeHelper(0x39, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL Application::CreateAddOn(short Position, const char* HintName, const char* ProgramFileName, const VARIANT& IconFileName)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_I2 VTS_BSTR VTS_BSTR VTS_VARIANT;
    InvokeHelper(0x3a, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        Position, HintName, ProgramFileName, &IconFileName);
    return result;
}

LPDISPATCH Application::AddMenu(const char* MenuName, LPDISPATCH VBXDispatch, const char* ProgramName, const VARIANT& ChartType)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_BSTR VTS_DISPATCH VTS_BSTR VTS_VARIANT;
    InvokeHelper(0x3b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        MenuName, VBXDispatch, ProgramName, &ChartType);
    return result;
}

void Application::Help(const VARIANT& HelpFileName, const VARIANT& HelpContext)
{
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x3c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         &HelpFileName, &HelpContext);
}

void Application::HidePercentGauge()
{
    InvokeHelper(0x3d, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Application::Hint(const char* HintText)
{
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x3e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         HintText);
}

long Application::MakeRGB(short Red, short Green, short Blue)
{
    long result;
    static BYTE BASED_CODE parms[] =
        VTS_I2 VTS_I2 VTS_I2;
    InvokeHelper(0x3f, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
        Red, Green, Blue);
    return result;
}

void Application::Maximize()
{
    InvokeHelper(0x40, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Application::Minimize()
{
    InvokeHelper(0x41, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

long Application::MsgBox(const char* MessageText, const VARIANT& BoxType, const VARIANT& BoxTitle)
{
    long result;
    static BYTE BASED_CODE parms[] =
        VTS_BSTR VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x42, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
        MessageText, &BoxType, &BoxTitle);
    return result;
}

LPDISPATCH Application::New()
{
    LPDISPATCH result;
    InvokeHelper(0x43, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH Application::NewFromTemplate(const char* TemplateName)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x44, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        TemplateName);
    return result;
}

LPDISPATCH Application::Open(const char* PathName, const VARIANT& AsReadOnly)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_BSTR VTS_VARIANT;
    InvokeHelper(0x45, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        PathName, &AsReadOnly);
    return result;
}

void Application::PercentGauge(const VARIANT& TitleBar, const VARIANT& TextLine1, const VARIANT& TextLine2)
{
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x46, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         &TitleBar, &TextLine1, &TextLine2);
}

BOOL Application::PercentGaugeCancelled()
{
    BOOL result;
    InvokeHelper(0x47, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}

void Application::Quit()
{
    InvokeHelper(0x48, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL Application::RegisterEvent(LPDISPATCH VBXDispatch, const char* ProgramName, const char* EventName, const VARIANT& ChartType)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_DISPATCH VTS_BSTR VTS_BSTR VTS_VARIANT;
    InvokeHelper(0x49, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        VBXDispatch, ProgramName, EventName, &ChartType);
    return result;
}

BOOL Application::RemoveAddOn(const VARIANT& Key)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x4a, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        &Key);
    return result;
}

void Application::RemoveMenu(const char* MenuName)
{
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x4b, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         MenuName);
}

void Application::Restore()
{
    InvokeHelper(0x4c, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Application::TileCharts()
{
    InvokeHelper(0x4d, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL Application::Undo()
{
    BOOL result;
    InvokeHelper(0x4e, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}

BOOL Application::UnRegisterEvent(LPDISPATCH VBXDispatch, const VARIANT& EventName, const VARIANT& ChartType)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_DISPATCH VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x4f, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        VBXDispatch, &EventName, &ChartType);
    return result;
}

BOOL Application::_UnRegAll(LPDISPATCH VBXDispatch)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x50, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        VBXDispatch);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// Charts properties

LPDISPATCH Charts::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

void Charts::SetApplication(LPDISPATCH propVal)
{
    SetProperty(0x1, VT_DISPATCH, propVal);
}

long Charts::GetCount()
{
    long result;
    GetProperty(0x2, VT_I4, (void*)&result);
    return result;
}

void Charts::SetCount(long propVal)
{
    SetProperty(0x2, VT_I4, propVal);
}

LPDISPATCH Charts::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x3, VT_DISPATCH, (void*)&result);
    return result;
}

void Charts::SetParent(LPDISPATCH propVal)
{
    SetProperty(0x3, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// Charts operations

LPDISPATCH Charts::Add()
{
    LPDISPATCH result;
    InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH Charts::AddFromTemplate(const char* TemplateName)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        TemplateName);
    return result;
}

void Charts::CloseAll()
{
    InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH Charts::Item(const VARIANT& PathName)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x7, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        &PathName);
    return result;
}

LPDISPATCH Charts::Open(const char* PathName, const VARIANT& AsReadOnly)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_BSTR VTS_VARIANT;
    InvokeHelper(0x8, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        PathName, &AsReadOnly);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// Chart properties

LPDISPATCH Chart::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

void Chart::SetApplication(LPDISPATCH propVal)
{
    SetProperty(0x1, VT_DISPATCH, propVal);
}

short Chart::GetCurrentLineRouting()
{
    short result;
    GetProperty(0x2, VT_I2, (void*)&result);
    return result;
}

void Chart::SetCurrentLineRouting(short propVal)
{
    SetProperty(0x2, VT_I2, propVal);
}

CString Chart::GetCurrentShape()
{
    CString result;
    GetProperty(0x3, VT_BSTR, (void*)&result);
    return result;
}

void Chart::SetCurrentShape(const char* propVal)
{
    SetProperty(0x3, VT_BSTR, propVal);
}

CString Chart::GetCurrentShapePalette()
{
    CString result;
    GetProperty(0x4, VT_BSTR, (void*)&result);
    return result;
}

void Chart::SetCurrentShapePalette(const char* propVal)
{
    SetProperty(0x4, VT_BSTR, propVal);
}

short Chart::GetDrawDirection()
{
    short result;
    GetProperty(0x5, VT_I2, (void*)&result);
    return result;
}

void Chart::SetDrawDirection(short propVal)
{
    SetProperty(0x5, VT_I2, propVal);
}

double Chart::GetDrawPositionX()
{
    double result;
    GetProperty(0x6, VT_R8, (void*)&result);
    return result;
}

void Chart::SetDrawPositionX(double propVal)
{
    SetProperty(0x6, VT_R8, propVal);
}

double Chart::GetDrawPositionY()
{
    double result;
    GetProperty(0x7, VT_R8, (void*)&result);
    return result;
}

void Chart::SetDrawPositionY(double propVal)
{
    SetProperty(0x7, VT_R8, propVal);
}

double Chart::GetDrawSpacingX()
{
    double result;
    GetProperty(0x8, VT_R8, (void*)&result);
    return result;
}

void Chart::SetDrawSpacingX(double propVal)
{
    SetProperty(0x8, VT_R8, propVal);
}

double Chart::GetDrawSpacingY()
{
    double result;
    GetProperty(0x9, VT_R8, (void*)&result);
    return result;
}

void Chart::SetDrawSpacingY(double propVal)
{
    SetProperty(0x9, VT_R8, propVal);
}

LPDISPATCH Chart::GetFieldFont()
{
    LPDISPATCH result;
    GetProperty(0xa, VT_DISPATCH, (void*)&result);
    return result;
}

void Chart::SetFieldFont(LPDISPATCH propVal)
{
    SetProperty(0xa, VT_DISPATCH, propVal);
}

BOOL Chart::GetFieldNamesHidden()
{
    BOOL result;
    GetProperty(0xb, VT_BOOL, (void*)&result);
    return result;
}

void Chart::SetFieldNamesHidden(BOOL propVal)
{
    SetProperty(0xb, VT_BOOL, propVal);
}

short Chart::GetFieldPlacement()
{
    short result;
    GetProperty(0xc, VT_I2, (void*)&result);
    return result;
}

void Chart::SetFieldPlacement(short propVal)
{
    SetProperty(0xc, VT_I2, propVal);
}

short Chart::GetFieldsDaysPerWeek()
{
    short result;
    GetProperty(0xd, VT_I2, (void*)&result);
    return result;
}

void Chart::SetFieldsDaysPerWeek(short propVal)
{
    SetProperty(0xd, VT_I2, propVal);
}

short Chart::GetFieldsHoursPerDay()
{
    short result;
    GetProperty(0xe, VT_I2, (void*)&result);
    return result;
}

void Chart::SetFieldsHoursPerDay(short propVal)
{
    SetProperty(0xe, VT_I2, propVal);
}

BOOL Chart::GetFieldsOpaque()
{
    BOOL result;
    GetProperty(0xf, VT_BOOL, (void*)&result);
    return result;
}

void Chart::SetFieldsOpaque(BOOL propVal)
{
    SetProperty(0xf, VT_BOOL, propVal);
}

LPDISPATCH Chart::GetFieldTemplates()
{
    LPDISPATCH result;
    GetProperty(0x10, VT_DISPATCH, (void*)&result);
    return result;
}

void Chart::SetFieldTemplates(LPDISPATCH propVal)
{
    SetProperty(0x10, VT_DISPATCH, propVal);
}

CString Chart::GetFullName()
{
    CString result;
    GetProperty(0x11, VT_BSTR, (void*)&result);
    return result;
}

void Chart::SetFullName(const char* propVal)
{
    SetProperty(0x11, VT_BSTR, propVal);
}

BOOL Chart::GetGuidelinesOn()
{
    BOOL result;
    GetProperty(0x12, VT_BOOL, (void*)&result);
    return result;
}

void Chart::SetGuidelinesOn(BOOL propVal)
{
    SetProperty(0x12, VT_BOOL, propVal);
}

BOOL Chart::GetHasDiskFile()
{
    BOOL result;
    GetProperty(0x13, VT_BOOL, (void*)&result);
    return result;
}

void Chart::SetHasDiskFile(BOOL propVal)
{
    SetProperty(0x13, VT_BOOL, propVal);
}

CString Chart::GetLaunchIndicator()
{
    CString result;
    GetProperty(0x14, VT_BSTR, (void*)&result);
    return result;
}

void Chart::SetLaunchIndicator(const char* propVal)
{
    SetProperty(0x14, VT_BSTR, propVal);
}

BOOL Chart::GetLaunchShadow()
{
    BOOL result;
    GetProperty(0x15, VT_BOOL, (void*)&result);
    return result;
}

void Chart::SetLaunchShadow(BOOL propVal)
{
    SetProperty(0x15, VT_BOOL, propVal);
}

short Chart::GetLineCrossoverSize()
{
    short result;
    GetProperty(0x16, VT_I2, (void*)&result);
    return result;
}

void Chart::SetLineCrossoverSize(short propVal)
{
    SetProperty(0x16, VT_I2, propVal);
}

short Chart::GetLineCrossoverStyle()
{
    short result;
    GetProperty(0x17, VT_I2, (void*)&result);
    return result;
}

void Chart::SetLineCrossoverStyle(short propVal)
{
    SetProperty(0x17, VT_I2, propVal);
}

CString Chart::GetLinkIndicator()
{
    CString result;
    GetProperty(0x18, VT_BSTR, (void*)&result);
    return result;
}

void Chart::SetLinkIndicator(const char* propVal)
{
    SetProperty(0x18, VT_BSTR, propVal);
}

BOOL Chart::GetLinkShadow()
{
    BOOL result;
    GetProperty(0x19, VT_BOOL, (void*)&result);
    return result;
}

void Chart::SetLinkShadow(BOOL propVal)
{
    SetProperty(0x19, VT_BOOL, propVal);
}

LPDISPATCH Chart::GetMasterItems()
{
    LPDISPATCH result;
    GetProperty(0x1a, VT_DISPATCH, (void*)&result);
    return result;
}

void Chart::SetMasterItems(LPDISPATCH propVal)
{
    SetProperty(0x1a, VT_DISPATCH, propVal);
}

CString Chart::GetName()
{
    CString result;
    GetProperty(0x1b, VT_BSTR, (void*)&result);
    return result;
}

void Chart::SetName(const char* propVal)
{
    SetProperty(0x1b, VT_BSTR, propVal);
}

CString Chart::GetNextNumber()
{
    CString result;
    GetProperty(0x1c, VT_BSTR, (void*)&result);
    return result;
}

void Chart::SetNextNumber(const char* propVal)
{
    SetProperty(0x1c, VT_BSTR, propVal);
}

double Chart::GetNextShapeHeight()
{
    double result;
    GetProperty(0x1d, VT_R8, (void*)&result);
    return result;
}

void Chart::SetNextShapeHeight(double propVal)
{
    SetProperty(0x1d, VT_R8, propVal);
}

double Chart::GetNextShapeWidth()
{
    double result;
    GetProperty(0x1e, VT_R8, (void*)&result);
    return result;
}

void Chart::SetNextShapeWidth(double propVal)
{
    SetProperty(0x1e, VT_R8, propVal);
}

BOOL Chart::GetNoRepaint()
{
    BOOL result;
    GetProperty(0x1f, VT_BOOL, (void*)&result);
    return result;
}

void Chart::SetNoRepaint(BOOL propVal)
{
    SetProperty(0x1f, VT_BOOL, propVal);
}

CString Chart::GetNoteIndicator()
{
    CString result;
    GetProperty(0x20, VT_BSTR, (void*)&result);
    return result;
}

void Chart::SetNoteIndicator(const char* propVal)
{
    SetProperty(0x20, VT_BSTR, propVal);
}

BOOL Chart::GetNoteShadow()
{
    BOOL result;
    GetProperty(0x21, VT_BOOL, (void*)&result);
    return result;
}

void Chart::SetNoteShadow(BOOL propVal)
{
    SetProperty(0x21, VT_BOOL, propVal);
}

LPDISPATCH Chart::GetObjects()
{
    LPDISPATCH result;
    GetProperty(0x22, VT_DISPATCH, (void*)&result);
    return result;
}

void Chart::SetObjects(LPDISPATCH propVal)
{
    SetProperty(0x22, VT_DISPATCH, propVal);
}

LPDISPATCH Chart::GetNumberFont()
{
    LPDISPATCH result;
    GetProperty(0x23, VT_DISPATCH, (void*)&result);
    return result;
}

void Chart::SetNumberFont(LPDISPATCH propVal)
{
    SetProperty(0x23, VT_DISPATCH, propVal);
}

short Chart::GetPageCount()
{
    short result;
    GetProperty(0x24, VT_I2, (void*)&result);
    return result;
}

void Chart::SetPageCount(short propVal)
{
    SetProperty(0x24, VT_I2, propVal);
}

LPDISPATCH Chart::GetPageLayout()
{
    LPDISPATCH result;
    GetProperty(0x25, VT_DISPATCH, (void*)&result);
    return result;
}

void Chart::SetPageLayout(LPDISPATCH propVal)
{
    SetProperty(0x25, VT_DISPATCH, propVal);
}

LPDISPATCH Chart::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x26, VT_DISPATCH, (void*)&result);
    return result;
}

void Chart::SetParent(LPDISPATCH propVal)
{
    SetProperty(0x26, VT_DISPATCH, propVal);
}

BOOL Chart::GetProtected()
{
    BOOL result;
    GetProperty(0x27, VT_BOOL, (void*)&result);
    return result;
}

void Chart::SetProtected(BOOL propVal)
{
    SetProperty(0x27, VT_BOOL, propVal);
}

BOOL Chart::GetReadOnly()
{
    BOOL result;
    GetProperty(0x28, VT_BOOL, (void*)&result);
    return result;
}

void Chart::SetReadOnly(BOOL propVal)
{
    SetProperty(0x28, VT_BOOL, propVal);
}

BOOL Chart::GetSaved()
{
    BOOL result;
    GetProperty(0x29, VT_BOOL, (void*)&result);
    return result;
}

void Chart::SetSaved(BOOL propVal)
{
    SetProperty(0x29, VT_BOOL, propVal);
}

double Chart::GetScrollLeft()
{
    double result;
    GetProperty(0x2a, VT_R8, (void*)&result);
    return result;
}

void Chart::SetScrollLeft(double propVal)
{
    SetProperty(0x2a, VT_R8, propVal);
}

double Chart::GetScrollTop()
{
    double result;
    GetProperty(0x2b, VT_R8, (void*)&result);
    return result;
}

void Chart::SetScrollTop(double propVal)
{
    SetProperty(0x2b, VT_R8, propVal);
}

long Chart::GetSelectedLineCount()
{
    long result;
    GetProperty(0x2c, VT_I4, (void*)&result);
    return result;
}

void Chart::SetSelectedLineCount(long propVal)
{
    SetProperty(0x2c, VT_I4, propVal);
}

long Chart::GetSelectedObjectCount()
{
    long result;
    GetProperty(0x2d, VT_I4, (void*)&result);
    return result;
}

void Chart::SetSelectedObjectCount(long propVal)
{
    SetProperty(0x2d, VT_I4, propVal);
}

long Chart::GetSelectedOtherCount()
{
    long result;
    GetProperty(0x2e, VT_I4, (void*)&result);
    return result;
}

void Chart::SetSelectedOtherCount(long propVal)
{
    SetProperty(0x2e, VT_I4, propVal);
}

long Chart::GetSelectedShapeCount()
{
    long result;
    GetProperty(0x2f, VT_I4, (void*)&result);
    return result;
}

void Chart::SetSelectedShapeCount(long propVal)
{
    SetProperty(0x2f, VT_I4, propVal);
}

BOOL Chart::GetShowLegend()
{
    BOOL result;
    GetProperty(0x30, VT_BOOL, (void*)&result);
    return result;
}

void Chart::SetShowLegend(BOOL propVal)
{
    SetProperty(0x30, VT_BOOL, propVal);
}

BOOL Chart::GetShowNodesOnLines()
{
    BOOL result;
    GetProperty(0x31, VT_BOOL, (void*)&result);
    return result;
}

void Chart::SetShowNodesOnLines(BOOL propVal)
{
    SetProperty(0x31, VT_BOOL, propVal);
}

CString Chart::GetType()
{
    CString result;
    GetProperty(0x32, VT_BSTR, (void*)&result);
    return result;
}

void Chart::SetType(const char* propVal)
{
    SetProperty(0x32, VT_BSTR, propVal);
}

BOOL Chart::GetTypeRequiresEXE()
{
    BOOL result;
    GetProperty(0x33, VT_BOOL, (void*)&result);
    return result;
}

void Chart::SetTypeRequiresEXE(BOOL propVal)
{
    SetProperty(0x33, VT_BOOL, propVal);
}

BOOL Chart::GetTypeUsesEXE()
{
    BOOL result;
    GetProperty(0x34, VT_BOOL, (void*)&result);
    return result;
}

void Chart::SetTypeUsesEXE(BOOL propVal)
{
    SetProperty(0x34, VT_BOOL, propVal);
}

short Chart::GetUnits()
{
    short result;
    GetProperty(0x35, VT_I2, (void*)&result);
    return result;
}

void Chart::SetUnits(short propVal)
{
    SetProperty(0x35, VT_I2, propVal);
}

BOOL Chart::GetValid()
{
    BOOL result;
    GetProperty(0x36, VT_BOOL, (void*)&result);
    return result;
}

void Chart::SetValid(BOOL propVal)
{
    SetProperty(0x36, VT_BOOL, propVal);
}

short Chart::GetView()
{
    short result;
    GetProperty(0x37, VT_I2, (void*)&result);
    return result;
}

void Chart::SetView(short propVal)
{
    SetProperty(0x37, VT_I2, propVal);
}

long Chart::GetWindowHandle()
{
    long result;
    GetProperty(0x38, VT_I4, (void*)&result);
    return result;
}

void Chart::SetWindowHandle(long propVal)
{
    SetProperty(0x38, VT_I4, propVal);
}

short Chart::GetZoomPercentage()
{
    short result;
    GetProperty(0x39, VT_I2, (void*)&result);
    return result;
}

void Chart::SetZoomPercentage(short propVal)
{
    SetProperty(0x39, VT_I2, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// Chart operations

void Chart::Activate()
{
    InvokeHelper(0x3a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Chart::AddHorizontalGuideline(double Position)
{
    static BYTE BASED_CODE parms[] =
        VTS_R8;
    InvokeHelper(0x3b, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         Position);
}

void Chart::AddVerticalGuideline(double Position)
{
    static BYTE BASED_CODE parms[] =
        VTS_R8;
    InvokeHelper(0x3c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         Position);
}

void Chart::CancelFullScreen()
{
    InvokeHelper(0x3d, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Chart::ClearGuidelines()
{
    InvokeHelper(0x3e, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL Chart::Clear()
{
    BOOL result;
    InvokeHelper(0x3f, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}

BOOL Chart::ClipboardFormatAvailable(short Format)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x6b, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        Format);
    return result;
}

void Chart::CloseChart()
{
    InvokeHelper(0x40, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL Chart::Copy()
{
    BOOL result;
    InvokeHelper(0x41, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}

BOOL Chart::Cut()
{
    BOOL result;
    InvokeHelper(0x42, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}

void Chart::DeselectAll()
{
    InvokeHelper(0x43, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH Chart::DrawFreeLine(double HorizontalLocation, double VerticalLocation)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_R8 VTS_R8;
    InvokeHelper(0x44, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        HorizontalLocation, VerticalLocation);
    return result;
}

LPDISPATCH Chart::DrawLine(LPDISPATCH ShapeObject1, LPDISPATCH ShapeObject2, const VARIANT& ExitDirection, const VARIANT& EnterDirection)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x45, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        ShapeObject1, ShapeObject2, &ExitDirection, &EnterDirection);
    return result;
}

LPDISPATCH Chart::DrawLineToOneObject(LPDISPATCH ShapeObject, const VARIANT& EnterDirection)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x46, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        ShapeObject, &EnterDirection);
    return result;
}

LPDISPATCH Chart::DrawShape(const VARIANT& ShapeName)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x47, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        &ShapeName);
    return result;
}

LPDISPATCH Chart::DrawTextBlock(const char* TextString)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x48, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        TextString);
    return result;
}

BOOL Chart::Duplicate()
{
    BOOL result;
    InvokeHelper(0x49, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}

BOOL Chart::FullScreen()
{
    BOOL result;
    InvokeHelper(0x4a, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}

LPDISPATCH Chart::GroupAndLink(const VARIANT& NewChartName, const VARIANT& FieldsLinked)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x4b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        &NewChartName, &FieldsLinked);
    return result;
}

LPDISPATCH Chart::InsertObjectFromFile(const char* Filename, const VARIANT& AsIcon, const VARIANT& AsLink)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_BSTR VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x4c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Filename, &AsIcon, &AsLink);
    return result;
}

void Chart::Maximize()
{
    InvokeHelper(0x4d, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Chart::Minimize()
{
    InvokeHelper(0x4e, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL Chart::Paste(double HorizontalLocation, double VerticalLocation)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_R8 VTS_R8;
    InvokeHelper(0x4f, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        HorizontalLocation, VerticalLocation);
    return result;
}

BOOL Chart::PasteLink(double HorizontalLocation, double VerticalLocation)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_R8 VTS_R8;
    InvokeHelper(0x50, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        HorizontalLocation, VerticalLocation);
    return result;
}

BOOL Chart::PasteSpecial(short Format, const VARIANT& AsIcon, double HorizontalLocation, double VerticalLocation)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_I2 VTS_VARIANT VTS_R8 VTS_R8;
    InvokeHelper(0x51, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        Format, &AsIcon, HorizontalLocation, VerticalLocation);
    return result;
}

BOOL Chart::PrintOut(const VARIANT& FromPage, const VARIANT& ToPage, const VARIANT& Copies, const VARIANT& FitToPage, const VARIANT& PrintNotes)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x52, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        &FromPage, &ToPage, &Copies, &FitToPage, &PrintNotes);
    return result;
}

BOOL Chart::PrintSelected(const VARIANT& Copies, const VARIANT& FitToPage, const VARIANT& PrintNotes)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x53, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        &Copies, &FitToPage, &PrintNotes);
    return result;
}

void Chart::Repaint()
{
    InvokeHelper(0x54, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Chart::Restore()
{
    InvokeHelper(0x55, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Chart::RevertToSaved()
{
    InvokeHelper(0x56, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL Chart::Save(const VARIANT& Path, const VARIANT& FileType)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x57, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        &Path, &FileType);
    return result;
}

void Chart::ScrollPage(short PageNumber)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x58, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         PageNumber);
}

void Chart::Select(short Value)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x59, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         Value);
}

void Chart::SelectShapeType(const char* ShapeName)
{
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x5a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         ShapeName);
}

BOOL Chart::SendMail()
{
    BOOL result;
    InvokeHelper(0x5b, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}

void Chart::SetDefaults(LPDISPATCH DefaultObject)
{
    static BYTE BASED_CODE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x5c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         DefaultObject);
}

void Chart::SetProtection(BOOL Protect, const char* Password)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL VTS_BSTR;
    InvokeHelper(0x5d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         Protect, Password);
}

void Chart::Spelling()
{
    InvokeHelper(0x5e, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Chart::ToBack()
{
    InvokeHelper(0x5f, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Chart::ToFront()
{
    InvokeHelper(0x60, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Chart::UpdateFields()
{
    InvokeHelper(0x61, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Chart::PrintPreview()
{
    InvokeHelper(0x62, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

long Chart::ReplaceText(const char* FindText, const char* ReplacementText, const VARIANT& MatchCase, const VARIANT& WholeWord)
{
    long result;
    static BYTE BASED_CODE parms[] =
        VTS_BSTR VTS_BSTR VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x63, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
        FindText, ReplacementText, &MatchCase, &WholeWord);
    return result;
}

BOOL Chart::Export(const char* Filename)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x64, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        Filename);
    return result;
}

BOOL Chart::SpaceEvenly(short Direction)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x65, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        Direction);
    return result;
}

BOOL Chart::MakeSameSize(short AccordingTo)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x66, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        AccordingTo);
    return result;
}

BOOL Chart::Align(short By)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x67, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        By);
    return result;
}

BOOL Chart::Clear_()
{
    BOOL result;
    InvokeHelper(0x68, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}

LPDISPATCH Chart::ImportShape(const char* Filename)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x69, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Filename);
    return result;
}

void Chart::ScrollPosition(double LeftDistance, double TopDistance)
{
    static BYTE BASED_CODE parms[] =
        VTS_R8 VTS_R8;
    InvokeHelper(0x6a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         LeftDistance, TopDistance);
}


/////////////////////////////////////////////////////////////////////////////
// FieldTemplates properties

LPDISPATCH FieldTemplates::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

void FieldTemplates::SetApplication(LPDISPATCH propVal)
{
    SetProperty(0x1, VT_DISPATCH, propVal);
}

long FieldTemplates::GetCount()
{
    long result;
    GetProperty(0x2, VT_I4, (void*)&result);
    return result;
}

void FieldTemplates::SetCount(long propVal)
{
    SetProperty(0x2, VT_I4, propVal);
}

LPDISPATCH FieldTemplates::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x3, VT_DISPATCH, (void*)&result);
    return result;
}

void FieldTemplates::SetParent(LPDISPATCH propVal)
{
    SetProperty(0x3, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// FieldTemplates operations

LPDISPATCH FieldTemplates::Add(const char* FieldName, const VARIANT& FieldType)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_BSTR VTS_VARIANT;
    InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        FieldName, &FieldType);
    return result;
}

void FieldTemplates::DeleteField(LPDISPATCH FieldTemplateObject)
{
    static BYTE BASED_CODE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         FieldTemplateObject);
}

LPDISPATCH FieldTemplates::Item(const VARIANT& CountOrFieldName, const VARIANT& FieldType)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        &CountOrFieldName, &FieldType);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// FieldTemplate properties

double FieldTemplate::GetAccumulation()
{
    double result;
    GetProperty(0x1, VT_R8, (void*)&result);
    return result;
}

void FieldTemplate::SetAccumulation(double propVal)
{
    SetProperty(0x1, VT_R8, propVal);
}

short FieldTemplate::GetAccumulationMethod()
{
    short result;
    GetProperty(0x2, VT_I2, (void*)&result);
    return result;
}

void FieldTemplate::SetAccumulationMethod(short propVal)
{
    SetProperty(0x2, VT_I2, propVal);
}

LPDISPATCH FieldTemplate::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x3, VT_DISPATCH, (void*)&result);
    return result;
}

void FieldTemplate::SetApplication(LPDISPATCH propVal)
{
    SetProperty(0x3, VT_DISPATCH, propVal);
}

LPDISPATCH FieldTemplate::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x4, VT_DISPATCH, (void*)&result);
    return result;
}

void FieldTemplate::SetParent(LPDISPATCH propVal)
{
    SetProperty(0x4, VT_DISPATCH, propVal);
}

short FieldTemplate::GetFormat()
{
    short result;
    GetProperty(0x5, VT_I2, (void*)&result);
    return result;
}

void FieldTemplate::SetFormat(short propVal)
{
    SetProperty(0x5, VT_I2, propVal);
}

BOOL FieldTemplate::GetHidden()
{
    BOOL result;
    GetProperty(0x6, VT_BOOL, (void*)&result);
    return result;
}

void FieldTemplate::SetHidden(BOOL propVal)
{
    SetProperty(0x6, VT_BOOL, propVal);
}

CString FieldTemplate::GetName()
{
    CString result;
    GetProperty(0x7, VT_BSTR, (void*)&result);
    return result;
}

void FieldTemplate::SetName(const char* propVal)
{
    SetProperty(0x7, VT_BSTR, propVal);
}

short FieldTemplate::GetType()
{
    short result;
    GetProperty(0x8, VT_I2, (void*)&result);
    return result;
}

void FieldTemplate::SetType(short propVal)
{
    SetProperty(0x8, VT_I2, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// FieldTemplate operations


/////////////////////////////////////////////////////////////////////////////
// FieldValues properties

LPDISPATCH FieldValues::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

void FieldValues::SetApplication(LPDISPATCH propVal)
{
    SetProperty(0x1, VT_DISPATCH, propVal);
}

long FieldValues::GetCount()
{
    long result;
    GetProperty(0x2, VT_I4, (void*)&result);
    return result;
}

void FieldValues::SetCount(long propVal)
{
    SetProperty(0x2, VT_I4, propVal);
}

LPDISPATCH FieldValues::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x3, VT_DISPATCH, (void*)&result);
    return result;
}

void FieldValues::SetParent(LPDISPATCH propVal)
{
    SetProperty(0x3, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// FieldValues operations

LPDISPATCH FieldValues::Item(const VARIANT& CountOrFileName, const VARIANT& FieldType)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        &CountOrFileName, &FieldType);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// FieldValue properties

LPDISPATCH FieldValue::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

void FieldValue::SetApplication(LPDISPATCH propVal)
{
    SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH FieldValue::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x2, VT_DISPATCH, (void*)&result);
    return result;
}

void FieldValue::SetParent(LPDISPATCH propVal)
{
    SetProperty(0x2, VT_DISPATCH, propVal);
}

short FieldValue::GetDay()
{
    short result;
    GetProperty(0x3, VT_I2, (void*)&result);
    return result;
}

void FieldValue::SetDay(short propVal)
{
    SetProperty(0x3, VT_I2, propVal);
}

LPDISPATCH FieldValue::GetFieldTemplate()
{
    LPDISPATCH result;
    GetProperty(0x4, VT_DISPATCH, (void*)&result);
    return result;
}

void FieldValue::SetFieldTemplate(LPDISPATCH propVal)
{
    SetProperty(0x4, VT_DISPATCH, propVal);
}

CString FieldValue::GetFormattedValue()
{
    CString result;
    GetProperty(0x5, VT_BSTR, (void*)&result);
    return result;
}

void FieldValue::SetFormattedValue(const char* propVal)
{
    SetProperty(0x5, VT_BSTR, propVal);
}

BOOL FieldValue::GetIsEmpty()
{
    BOOL result;
    GetProperty(0x6, VT_BOOL, (void*)&result);
    return result;
}

void FieldValue::SetIsEmpty(BOOL propVal)
{
    SetProperty(0x6, VT_BOOL, propVal);
}

short FieldValue::GetMonth()
{
    short result;
    GetProperty(0x7, VT_I2, (void*)&result);
    return result;
}

void FieldValue::SetMonth(short propVal)
{
    SetProperty(0x7, VT_I2, propVal);
}

CString FieldValue::GetName()
{
    CString result;
    GetProperty(0x8, VT_BSTR, (void*)&result);
    return result;
}

void FieldValue::SetName(const char* propVal)
{
    SetProperty(0x8, VT_BSTR, propVal);
}

short FieldValue::GetType()
{
    short result;
    GetProperty(0x9, VT_I2, (void*)&result);
    return result;
}

void FieldValue::SetType(short propVal)
{
    SetProperty(0x9, VT_I2, propVal);
}

VARIANT FieldValue::GetValue()
{
    VARIANT result;
    GetProperty(0xa, VT_VARIANT, (void*)&result);
    return result;
}

void FieldValue::SetValue(const VARIANT& propVal)
{
    SetProperty(0xa, VT_VARIANT, &propVal);
}

short FieldValue::GetYear()
{
    short result;
    GetProperty(0xb, VT_I2, (void*)&result);
    return result;
}

void FieldValue::SetYear(short propVal)
{
    SetProperty(0xb, VT_I2, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// FieldValue operations

void FieldValue::Empty()
{
    InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// FontObject properties

LPDISPATCH FontObject::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

void FontObject::SetApplication(LPDISPATCH propVal)
{
    SetProperty(0x1, VT_DISPATCH, propVal);
}

BOOL FontObject::GetBold()
{
    BOOL result;
    GetProperty(0x2, VT_BOOL, (void*)&result);
    return result;
}

void FontObject::SetBold(BOOL propVal)
{
    SetProperty(0x2, VT_BOOL, propVal);
}

long FontObject::GetColor()
{
    long result;
    GetProperty(0x3, VT_I4, (void*)&result);
    return result;
}

void FontObject::SetColor(long propVal)
{
    SetProperty(0x3, VT_I4, propVal);
}

BOOL FontObject::GetItalic()
{
    BOOL result;
    GetProperty(0x4, VT_BOOL, (void*)&result);
    return result;
}

void FontObject::SetItalic(BOOL propVal)
{
    SetProperty(0x4, VT_BOOL, propVal);
}

CString FontObject::GetName()
{
    CString result;
    GetProperty(0x5, VT_BSTR, (void*)&result);
    return result;
}

void FontObject::SetName(const char* propVal)
{
    SetProperty(0x5, VT_BSTR, propVal);
}

BOOL FontObject::GetOpaque()
{
    BOOL result;
    GetProperty(0x6, VT_BOOL, (void*)&result);
    return result;
}

void FontObject::SetOpaque(BOOL propVal)
{
    SetProperty(0x6, VT_BOOL, propVal);
}

LPDISPATCH FontObject::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x7, VT_DISPATCH, (void*)&result);
    return result;
}

void FontObject::SetParent(LPDISPATCH propVal)
{
    SetProperty(0x7, VT_DISPATCH, propVal);
}

double FontObject::GetSize()
{
    double result;
    GetProperty(0x8, VT_R8, (void*)&result);
    return result;
}

void FontObject::SetSize(double propVal)
{
    SetProperty(0x8, VT_R8, propVal);
}

BOOL FontObject::GetStrikethrough()
{
    BOOL result;
    GetProperty(0x9, VT_BOOL, (void*)&result);
    return result;
}

void FontObject::SetStrikethrough(BOOL propVal)
{
    SetProperty(0x9, VT_BOOL, propVal);
}

BOOL FontObject::GetUnderline()
{
    BOOL result;
    GetProperty(0xa, VT_BOOL, (void*)&result);
    return result;
}

void FontObject::SetUnderline(BOOL propVal)
{
    SetProperty(0xa, VT_BOOL, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// FontObject operations


/////////////////////////////////////////////////////////////////////////////
// LineObject properties

LPDISPATCH LineObject::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

void LineObject::SetApplication(LPDISPATCH propVal)
{
    SetProperty(0x1, VT_DISPATCH, propVal);
}

long LineObject::GetColor()
{
    long result;
    GetProperty(0x2, VT_I4, (void*)&result);
    return result;
}

void LineObject::SetColor(long propVal)
{
    SetProperty(0x2, VT_I4, propVal);
}

long LineObject::GetDestArrowColor()
{
    long result;
    GetProperty(0x3, VT_I4, (void*)&result);
    return result;
}

void LineObject::SetDestArrowColor(long propVal)
{
    SetProperty(0x3, VT_I4, propVal);
}

short LineObject::GetDestArrowSize()
{
    short result;
    GetProperty(0x4, VT_I2, (void*)&result);
    return result;
}

void LineObject::SetDestArrowSize(short propVal)
{
    SetProperty(0x4, VT_I2, propVal);
}

short LineObject::GetDestArrowStyle()
{
    short result;
    GetProperty(0x5, VT_I2, (void*)&result);
    return result;
}

void LineObject::SetDestArrowStyle(short propVal)
{
    SetProperty(0x5, VT_I2, propVal);
}

LPDISPATCH LineObject::GetDestination()
{
    LPDISPATCH result;
    GetProperty(0x6, VT_DISPATCH, (void*)&result);
    return result;
}

void LineObject::SetDestination(LPDISPATCH propVal)
{
    SetProperty(0x6, VT_DISPATCH, propVal);
}

short LineObject::GetDestinationDirection()
{
    short result;
    GetProperty(0x7, VT_I2, (void*)&result);
    return result;
}

void LineObject::SetDestinationDirection(short propVal)
{
    SetProperty(0x7, VT_I2, propVal);
}

LPDISPATCH LineObject::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x8, VT_DISPATCH, (void*)&result);
    return result;
}

void LineObject::SetParent(LPDISPATCH propVal)
{
    SetProperty(0x8, VT_DISPATCH, propVal);
}

LPDISPATCH LineObject::GetSource()
{
    LPDISPATCH result;
    GetProperty(0x9, VT_DISPATCH, (void*)&result);
    return result;
}

void LineObject::SetSource(LPDISPATCH propVal)
{
    SetProperty(0x9, VT_DISPATCH, propVal);
}

long LineObject::GetSourceArrowColor()
{
    long result;
    GetProperty(0xa, VT_I4, (void*)&result);
    return result;
}

void LineObject::SetSourceArrowColor(long propVal)
{
    SetProperty(0xa, VT_I4, propVal);
}

short LineObject::GetSourceArrowStyle()
{
    short result;
    GetProperty(0xb, VT_I2, (void*)&result);
    return result;
}

void LineObject::SetSourceArrowStyle(short propVal)
{
    SetProperty(0xb, VT_I2, propVal);
}

short LineObject::GetSourceArrowSize()
{
    short result;
    GetProperty(0xc, VT_I2, (void*)&result);
    return result;
}

void LineObject::SetSourceArrowSize(short propVal)
{
    SetProperty(0xc, VT_I2, propVal);
}

short LineObject::GetSourceDirection()
{
    short result;
    GetProperty(0xd, VT_I2, (void*)&result);
    return result;
}

void LineObject::SetSourceDirection(short propVal)
{
    SetProperty(0xd, VT_I2, propVal);
}

long LineObject::GetStemColor()
{
    long result;
    GetProperty(0xe, VT_I4, (void*)&result);
    return result;
}

void LineObject::SetStemColor(long propVal)
{
    SetProperty(0xe, VT_I4, propVal);
}

short LineObject::GetStemStyle()
{
    short result;
    GetProperty(0xf, VT_I2, (void*)&result);
    return result;
}

void LineObject::SetStemStyle(short propVal)
{
    SetProperty(0xf, VT_I2, propVal);
}

short LineObject::GetStemWidth()
{
    short result;
    GetProperty(0x10, VT_I2, (void*)&result);
    return result;
}

void LineObject::SetStemWidth(short propVal)
{
    SetProperty(0x10, VT_I2, propVal);
}

short LineObject::GetType()
{
    short result;
    GetProperty(0x11, VT_I2, (void*)&result);
    return result;
}

void LineObject::SetType(short propVal)
{
    SetProperty(0x11, VT_I2, propVal);
}

short LineObject::GetRouting()
{
    short result;
    GetProperty(0x12, VT_I2, (void*)&result);
    return result;
}

void LineObject::SetRouting(short propVal)
{
    SetProperty(0x12, VT_I2, propVal);
}

short LineObject::GetCrossoverSize()
{
    short result;
    GetProperty(0x13, VT_I2, (void*)&result);
    return result;
}

void LineObject::SetCrossoverSize(short propVal)
{
    SetProperty(0x13, VT_I2, propVal);
}

short LineObject::GetCrossoverStyle()
{
    short result;
    GetProperty(0x14, VT_I2, (void*)&result);
    return result;
}

void LineObject::SetCrossoverStyle(short propVal)
{
    SetProperty(0x14, VT_I2, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// LineObject operations

BOOL LineObject::AttachText(LPDISPATCH TextObject, const VARIANT& LineSegment)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x15, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        TextObject, &LineSegment);
    return result;
}

BOOL LineObject::ReconnectDest(LPDISPATCH ShapeObject, const VARIANT& EnterDirection)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x16, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        ShapeObject, &EnterDirection);
    return result;
}

BOOL LineObject::ReconnectSource(LPDISPATCH ShapeObject, const VARIANT& ExitDirection)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x17, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        ShapeObject, &ExitDirection);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// MasterItems properties

LPDISPATCH MasterItems::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

void MasterItems::SetApplication(LPDISPATCH propVal)
{
    SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH MasterItems::GetChartName()
{
    LPDISPATCH result;
    GetProperty(0x2, VT_DISPATCH, (void*)&result);
    return result;
}

void MasterItems::SetChartName(LPDISPATCH propVal)
{
    SetProperty(0x2, VT_DISPATCH, propVal);
}

BOOL MasterItems::GetChartNameShown()
{
    BOOL result;
    GetProperty(0x3, VT_BOOL, (void*)&result);
    return result;
}

void MasterItems::SetChartNameShown(BOOL propVal)
{
    SetProperty(0x3, VT_BOOL, propVal);
}

LPDISPATCH MasterItems::GetDate()
{
    LPDISPATCH result;
    GetProperty(0x4, VT_DISPATCH, (void*)&result);
    return result;
}

void MasterItems::SetDate(LPDISPATCH propVal)
{
    SetProperty(0x4, VT_DISPATCH, propVal);
}

BOOL MasterItems::GetDateShown()
{
    BOOL result;
    GetProperty(0x5, VT_BOOL, (void*)&result);
    return result;
}

void MasterItems::SetDateShown(BOOL propVal)
{
    SetProperty(0x5, VT_BOOL, propVal);
}

short MasterItems::GetDateStyle()
{
    short result;
    GetProperty(0x6, VT_I2, (void*)&result);
    return result;
}

void MasterItems::SetDateStyle(short propVal)
{
    SetProperty(0x6, VT_I2, propVal);
}

LPDISPATCH MasterItems::GetLogo()
{
    LPDISPATCH result;
    GetProperty(0x7, VT_DISPATCH, (void*)&result);
    return result;
}

void MasterItems::SetLogo(LPDISPATCH propVal)
{
    SetProperty(0x7, VT_DISPATCH, propVal);
}

BOOL MasterItems::GetLogoShown()
{
    BOOL result;
    GetProperty(0x8, VT_BOOL, (void*)&result);
    return result;
}

void MasterItems::SetLogoShown(BOOL propVal)
{
    SetProperty(0x8, VT_BOOL, propVal);
}

LPDISPATCH MasterItems::GetPageNumber()
{
    LPDISPATCH result;
    GetProperty(0x9, VT_DISPATCH, (void*)&result);
    return result;
}

void MasterItems::SetPageNumber(LPDISPATCH propVal)
{
    SetProperty(0x9, VT_DISPATCH, propVal);
}

BOOL MasterItems::GetPageNumberShown()
{
    BOOL result;
    GetProperty(0xa, VT_BOOL, (void*)&result);
    return result;
}

void MasterItems::SetPageNumberShown(BOOL propVal)
{
    SetProperty(0xa, VT_BOOL, propVal);
}

LPDISPATCH MasterItems::GetParent()
{
    LPDISPATCH result;
    GetProperty(0xb, VT_DISPATCH, (void*)&result);
    return result;
}

void MasterItems::SetParent(LPDISPATCH propVal)
{
    SetProperty(0xb, VT_DISPATCH, propVal);
}

short MasterItems::GetRange()
{
    short result;
    GetProperty(0xc, VT_I2, (void*)&result);
    return result;
}

void MasterItems::SetRange(short propVal)
{
    SetProperty(0xc, VT_I2, propVal);
}

LPDISPATCH MasterItems::GetText1()
{
    LPDISPATCH result;
    GetProperty(0xd, VT_DISPATCH, (void*)&result);
    return result;
}

void MasterItems::SetText1(LPDISPATCH propVal)
{
    SetProperty(0xd, VT_DISPATCH, propVal);
}

LPDISPATCH MasterItems::GetText2()
{
    LPDISPATCH result;
    GetProperty(0xe, VT_DISPATCH, (void*)&result);
    return result;
}

void MasterItems::SetText2(LPDISPATCH propVal)
{
    SetProperty(0xe, VT_DISPATCH, propVal);
}

BOOL MasterItems::GetText1Shown()
{
    BOOL result;
    GetProperty(0xf, VT_BOOL, (void*)&result);
    return result;
}

void MasterItems::SetText1Shown(BOOL propVal)
{
    SetProperty(0xf, VT_BOOL, propVal);
}

BOOL MasterItems::GetText2Shown()
{
    BOOL result;
    GetProperty(0x10, VT_BOOL, (void*)&result);
    return result;
}

void MasterItems::SetText2Shown(BOOL propVal)
{
    SetProperty(0x10, VT_BOOL, propVal);
}

LPDISPATCH MasterItems::GetTime()
{
    LPDISPATCH result;
    GetProperty(0x11, VT_DISPATCH, (void*)&result);
    return result;
}

void MasterItems::SetTime(LPDISPATCH propVal)
{
    SetProperty(0x11, VT_DISPATCH, propVal);
}

BOOL MasterItems::GetTimeShown()
{
    BOOL result;
    GetProperty(0x12, VT_BOOL, (void*)&result);
    return result;
}

void MasterItems::SetTimeShown(BOOL propVal)
{
    SetProperty(0x12, VT_BOOL, propVal);
}

CString MasterItems::GetLogoPathname()
{
    CString result;
    GetProperty(0x13, VT_BSTR, (void*)&result);
    return result;
}

void MasterItems::SetLogoPathname(const char* propVal)
{
    SetProperty(0x13, VT_BSTR, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// MasterItems operations

void MasterItems::HideAll()
{
    InvokeHelper(0x14, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void MasterItems::ShowAll()
{
    InvokeHelper(0x15, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void MasterItems::UpdateDateAndTime(const VARIANT& Date, const VARIANT& Time)
{
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x16, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         &Date, &Time);
}


/////////////////////////////////////////////////////////////////////////////
// MenuObject properties

LPDISPATCH MenuObject::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

void MenuObject::SetApplication(LPDISPATCH propVal)
{
    SetProperty(0x1, VT_DISPATCH, propVal);
}

long MenuObject::GetCount()
{
    long result;
    GetProperty(0x2, VT_I4, (void*)&result);
    return result;
}

void MenuObject::SetCount(long propVal)
{
    SetProperty(0x2, VT_I4, propVal);
}

LPDISPATCH MenuObject::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x3, VT_DISPATCH, (void*)&result);
    return result;
}

void MenuObject::SetParent(LPDISPATCH propVal)
{
    SetProperty(0x3, VT_DISPATCH, propVal);
}

CString MenuObject::GetText()
{
    CString result;
    GetProperty(0x4, VT_BSTR, (void*)&result);
    return result;
}

void MenuObject::SetText(const char* propVal)
{
    SetProperty(0x4, VT_BSTR, propVal);
}

BOOL MenuObject::GetVisible()
{
    BOOL result;
    GetProperty(0x5, VT_BOOL, (void*)&result);
    return result;
}

void MenuObject::SetVisible(BOOL propVal)
{
    SetProperty(0x5, VT_BOOL, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// MenuObject operations

LPDISPATCH MenuObject::AppendItem(const char* ItemName)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        ItemName);
    return result;
}

void MenuObject::DeleteAll()
{
    InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void MenuObject::DeleteItem(LPDISPATCH MenuItem)
{
    static BYTE BASED_CODE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         MenuItem);
}

LPDISPATCH MenuObject::InsertItem(const char* ItemName, const VARIANT& PreviousItemOrPos)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_BSTR VTS_VARIANT;
    InvokeHelper(0x9, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        ItemName, &PreviousItemOrPos);
    return result;
}

LPDISPATCH MenuObject::GetItem(const VARIANT& ItemTextOrPostion)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT;
    InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        &ItemTextOrPostion);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// MenuItem properties

LPDISPATCH MenuItem::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

void MenuItem::SetApplication(LPDISPATCH propVal)
{
    SetProperty(0x1, VT_DISPATCH, propVal);
}

BOOL MenuItem::GetChecked()
{
    BOOL result;
    GetProperty(0x2, VT_BOOL, (void*)&result);
    return result;
}

void MenuItem::SetChecked(BOOL propVal)
{
    SetProperty(0x2, VT_BOOL, propVal);
}

BOOL MenuItem::GetEnabled()
{
    BOOL result;
    GetProperty(0x3, VT_BOOL, (void*)&result);
    return result;
}

void MenuItem::SetEnabled(BOOL propVal)
{
    SetProperty(0x3, VT_BOOL, propVal);
}

LPDISPATCH MenuItem::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x4, VT_DISPATCH, (void*)&result);
    return result;
}

void MenuItem::SetParent(LPDISPATCH propVal)
{
    SetProperty(0x4, VT_DISPATCH, propVal);
}

CString MenuItem::GetText()
{
    CString result;
    GetProperty(0x5, VT_BSTR, (void*)&result);
    return result;
}

void MenuItem::SetText(const char* propVal)
{
    SetProperty(0x5, VT_BSTR, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// MenuItem operations


/////////////////////////////////////////////////////////////////////////////
// Objects properties

LPDISPATCH Objects::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

void Objects::SetApplication(LPDISPATCH propVal)
{
    SetProperty(0x1, VT_DISPATCH, propVal);
}

long Objects::GetCount()
{
    long result;
    GetProperty(0x2, VT_I4, (void*)&result);
    return result;
}

void Objects::SetCount(long propVal)
{
    SetProperty(0x2, VT_I4, propVal);
}

LPDISPATCH Objects::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x3, VT_DISPATCH, (void*)&result);
    return result;
}

void Objects::SetParent(LPDISPATCH propVal)
{
    SetProperty(0x3, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// Objects operations

LPDISPATCH Objects::Item(long Count)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_I4;
    InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Count);
    return result;
}

LPDISPATCH Objects::ItemFromAll()
{
    LPDISPATCH result;
    InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH Objects::ItemFromAttachments(LPDISPATCH ObjectWithAttach1, LPDISPATCH ObjectWithAttach2)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        ObjectWithAttach1, ObjectWithAttach2);
    return result;
}

LPDISPATCH Objects::ItemFromFieldValue(LPDISPATCH FieldTemplateObject, const VARIANT& Value)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x7, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        FieldTemplateObject, &Value);
    return result;
}

LPDISPATCH Objects::ItemFromLines()
{
    LPDISPATCH result;
    InvokeHelper(0x8, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH Objects::ItemFromShapes()
{
    LPDISPATCH result;
    InvokeHelper(0x9, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH Objects::ItemFromSelection()
{
    LPDISPATCH result;
    InvokeHelper(0xa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH Objects::ItemFromNumber(const VARIANT& Value)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT;
    InvokeHelper(0xb, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        &Value);
    return result;
}

LPDISPATCH Objects::ItemFromText(const char* Text)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0xc, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Text);
    return result;
}

LPDISPATCH Objects::ItemFromUniqueID(long UniqueID)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_I4;
    InvokeHelper(0xd, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        UniqueID);
    return result;
}

void Objects::ResetSearch()
{
    InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// Object properties

LPDISPATCH Object::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

void Object::SetApplication(LPDISPATCH propVal)
{
    SetProperty(0x1, VT_DISPATCH, propVal);
}

double Object::GetBottom()
{
    double result;
    GetProperty(0x2, VT_R8, (void*)&result);
    return result;
}

void Object::SetBottom(double propVal)
{
    SetProperty(0x2, VT_R8, propVal);
}

double Object::GetCenterX()
{
    double result;
    GetProperty(0x3, VT_R8, (void*)&result);
    return result;
}

void Object::SetCenterX(double propVal)
{
    SetProperty(0x3, VT_R8, propVal);
}

double Object::GetCenterY()
{
    double result;
    GetProperty(0x4, VT_R8, (void*)&result);
    return result;
}

void Object::SetCenterY(double propVal)
{
    SetProperty(0x4, VT_R8, propVal);
}

long Object::GetColor()
{
    long result;
    GetProperty(0x5, VT_I4, (void*)&result);
    return result;
}

void Object::SetColor(long propVal)
{
    SetProperty(0x5, VT_I4, propVal);
}

LPDISPATCH Object::GetFieldValues()
{
    LPDISPATCH result;
    GetProperty(0x6, VT_DISPATCH, (void*)&result);
    return result;
}

void Object::SetFieldValues(LPDISPATCH propVal)
{
    SetProperty(0x6, VT_DISPATCH, propVal);
}

LPDISPATCH Object::GetFont()
{
    LPDISPATCH result;
    GetProperty(0x7, VT_DISPATCH, (void*)&result);
    return result;
}

void Object::SetFont(LPDISPATCH propVal)
{
    SetProperty(0x7, VT_DISPATCH, propVal);
}

double Object::GetHeight()
{
    double result;
    GetProperty(0x8, VT_R8, (void*)&result);
    return result;
}

void Object::SetHeight(double propVal)
{
    SetProperty(0x8, VT_R8, propVal);
}

double Object::GetLeft()
{
    double result;
    GetProperty(0x9, VT_R8, (void*)&result);
    return result;
}

void Object::SetLeft(double propVal)
{
    SetProperty(0x9, VT_R8, propVal);
}

LPDISPATCH Object::GetLine()
{
    LPDISPATCH result;
    GetProperty(0xa, VT_DISPATCH, (void*)&result);
    return result;
}

void Object::SetLine(LPDISPATCH propVal)
{
    SetProperty(0xa, VT_DISPATCH, propVal);
}

LPDISPATCH Object::GetOle()
{
    LPDISPATCH result;
    GetProperty(0xb, VT_DISPATCH, (void*)&result);
    return result;
}

void Object::SetOle(LPDISPATCH propVal)
{
    SetProperty(0xb, VT_DISPATCH, propVal);
}

LPDISPATCH Object::GetParent()
{
    LPDISPATCH result;
    GetProperty(0xc, VT_DISPATCH, (void*)&result);
    return result;
}

void Object::SetParent(LPDISPATCH propVal)
{
    SetProperty(0xc, VT_DISPATCH, propVal);
}

double Object::GetRight()
{
    double result;
    GetProperty(0xd, VT_R8, (void*)&result);
    return result;
}

void Object::SetRight(double propVal)
{
    SetProperty(0xd, VT_R8, propVal);
}

BOOL Object::GetSelected()
{
    BOOL result;
    GetProperty(0xe, VT_BOOL, (void*)&result);
    return result;
}

void Object::SetSelected(BOOL propVal)
{
    SetProperty(0xe, VT_BOOL, propVal);
}

LPDISPATCH Object::GetShape()
{
    LPDISPATCH result;
    GetProperty(0xf, VT_DISPATCH, (void*)&result);
    return result;
}

void Object::SetShape(LPDISPATCH propVal)
{
    SetProperty(0xf, VT_DISPATCH, propVal);
}

short Object::GetStretchType()
{
    short result;
    GetProperty(0x10, VT_I2, (void*)&result);
    return result;
}

void Object::SetStretchType(short propVal)
{
    SetProperty(0x10, VT_I2, propVal);
}

CString Object::GetText()
{
    CString result;
    GetProperty(0x11, VT_BSTR, (void*)&result);
    return result;
}

void Object::SetText(const char* propVal)
{
    SetProperty(0x11, VT_BSTR, propVal);
}

CString Object::GetTextLF()
{
    CString result;
    GetProperty(0x12, VT_BSTR, (void*)&result);
    return result;
}

void Object::SetTextLF(const char* propVal)
{
    SetProperty(0x12, VT_BSTR, propVal);
}

short Object::GetTextAlignment()
{
    short result;
    GetProperty(0x13, VT_I2, (void*)&result);
    return result;
}

void Object::SetTextAlignment(short propVal)
{
    SetProperty(0x13, VT_I2, propVal);
}

LPDISPATCH Object::GetTextBlock()
{
    LPDISPATCH result;
    GetProperty(0x14, VT_DISPATCH, (void*)&result);
    return result;
}

void Object::SetTextBlock(LPDISPATCH propVal)
{
    SetProperty(0x14, VT_DISPATCH, propVal);
}

double Object::GetTop()
{
    double result;
    GetProperty(0x15, VT_R8, (void*)&result);
    return result;
}

void Object::SetTop(double propVal)
{
    SetProperty(0x15, VT_R8, propVal);
}

short Object::GetType()
{
    short result;
    GetProperty(0x16, VT_I2, (void*)&result);
    return result;
}

void Object::SetType(short propVal)
{
    SetProperty(0x16, VT_I2, propVal);
}

long Object::GetUniqueID()
{
    long result;
    GetProperty(0x17, VT_I4, (void*)&result);
    return result;
}

void Object::SetUniqueID(long propVal)
{
    SetProperty(0x17, VT_I4, propVal);
}

BOOL Object::GetValid()
{
    BOOL result;
    GetProperty(0x18, VT_BOOL, (void*)&result);
    return result;
}

void Object::SetValid(BOOL propVal)
{
    SetProperty(0x18, VT_BOOL, propVal);
}

double Object::GetWidth()
{
    double result;
    GetProperty(0x19, VT_R8, (void*)&result);
    return result;
}

void Object::SetWidth(double propVal)
{
    SetProperty(0x19, VT_R8, propVal);
}

BOOL Object::GetFlippedVertical()
{
    BOOL result;
    GetProperty(0x1a, VT_BOOL, (void*)&result);
    return result;
}

void Object::SetFlippedVertical(BOOL propVal)
{
    SetProperty(0x1a, VT_BOOL, propVal);
}

BOOL Object::GetFlippedHorizontal()
{
    BOOL result;
    GetProperty(0x1b, VT_BOOL, (void*)&result);
    return result;
}

void Object::SetFlippedHorizontal(BOOL propVal)
{
    SetProperty(0x1b, VT_BOOL, propVal);
}

short Object::GetRotation()
{
    short result;
    GetProperty(0x1c, VT_I2, (void*)&result);
    return result;
}

void Object::SetRotation(short propVal)
{
    SetProperty(0x1c, VT_I2, propVal);
}

LPDISPATCH Object::GetLine_()
{
    LPDISPATCH result;
    GetProperty(0x1d, VT_DISPATCH, (void*)&result);
    return result;
}

void Object::SetLine_(LPDISPATCH propVal)
{
    SetProperty(0x1d, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// Object operations

BOOL Object::Clear()
{
    BOOL result;
    InvokeHelper(0x1e, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}

LPDISPATCH Object::Duplicate()
{
    LPDISPATCH result;
    InvokeHelper(0x1f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

void Object::Repaint()
{
    InvokeHelper(0x20, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Object::RestorePicture()
{
    InvokeHelper(0x21, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Object::ToBack()
{
    InvokeHelper(0x22, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Object::ToFront()
{
    InvokeHelper(0x23, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Object::ApplyDefaults()
{
    InvokeHelper(0x24, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL Object::Clear_()
{
    BOOL result;
    InvokeHelper(0x25, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// OLEObject properties

LPDISPATCH OLEObject::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

void OLEObject::SetApplication(LPDISPATCH propVal)
{
    SetProperty(0x1, VT_DISPATCH, propVal);
}

CString OLEObject::GetObjectType()
{
    CString result;
    GetProperty(0x2, VT_BSTR, (void*)&result);
    return result;
}

void OLEObject::SetObjectType(const char* propVal)
{
    SetProperty(0x2, VT_BSTR, propVal);
}

LPDISPATCH OLEObject::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x3, VT_DISPATCH, (void*)&result);
    return result;
}

void OLEObject::SetParent(LPDISPATCH propVal)
{
    SetProperty(0x3, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// OLEObject operations

void OLEObject::DoVerb(const VARIANT& Verb)
{
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         &Verb);
}

void OLEObject::RestorePicture()
{
    InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// PageLayout properties

LPDISPATCH PageLayout::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

void PageLayout::SetApplication(LPDISPATCH propVal)
{
    SetProperty(0x1, VT_DISPATCH, propVal);
}

double PageLayout::GetHeight()
{
    double result;
    GetProperty(0x2, VT_R8, (void*)&result);
    return result;
}

void PageLayout::SetHeight(double propVal)
{
    SetProperty(0x2, VT_R8, propVal);
}

double PageLayout::GetMarginBottom()
{
    double result;
    GetProperty(0x3, VT_R8, (void*)&result);
    return result;
}

void PageLayout::SetMarginBottom(double propVal)
{
    SetProperty(0x3, VT_R8, propVal);
}

double PageLayout::GetMarginLeft()
{
    double result;
    GetProperty(0x4, VT_R8, (void*)&result);
    return result;
}

void PageLayout::SetMarginLeft(double propVal)
{
    SetProperty(0x4, VT_R8, propVal);
}

double PageLayout::GetMarginRight()
{
    double result;
    GetProperty(0x5, VT_R8, (void*)&result);
    return result;
}

void PageLayout::SetMarginRight(double propVal)
{
    SetProperty(0x5, VT_R8, propVal);
}

double PageLayout::GetMarginTop()
{
    double result;
    GetProperty(0x6, VT_R8, (void*)&result);
    return result;
}

void PageLayout::SetMarginTop(double propVal)
{
    SetProperty(0x6, VT_R8, propVal);
}

short PageLayout::GetOrientation()
{
    short result;
    GetProperty(0x7, VT_I2, (void*)&result);
    return result;
}

void PageLayout::SetOrientation(short propVal)
{
    SetProperty(0x7, VT_I2, propVal);
}

double PageLayout::GetPageHeight()
{
    double result;
    GetProperty(0x8, VT_R8, (void*)&result);
    return result;
}

void PageLayout::SetPageHeight(double propVal)
{
    SetProperty(0x8, VT_R8, propVal);
}

double PageLayout::GetPageWidth()
{
    double result;
    GetProperty(0x9, VT_R8, (void*)&result);
    return result;
}

void PageLayout::SetPageWidth(double propVal)
{
    SetProperty(0x9, VT_R8, propVal);
}

short PageLayout::GetPageOrder()
{
    short result;
    GetProperty(0xa, VT_I2, (void*)&result);
    return result;
}

void PageLayout::SetPageOrder(short propVal)
{
    SetProperty(0xa, VT_I2, propVal);
}

CString PageLayout::GetPaperSize()
{
    CString result;
    GetProperty(0xb, VT_BSTR, (void*)&result);
    return result;
}

void PageLayout::SetPaperSize(const char* propVal)
{
    SetProperty(0xb, VT_BSTR, propVal);
}

LPDISPATCH PageLayout::GetParent()
{
    LPDISPATCH result;
    GetProperty(0xc, VT_DISPATCH, (void*)&result);
    return result;
}

void PageLayout::SetParent(LPDISPATCH propVal)
{
    SetProperty(0xc, VT_DISPATCH, propVal);
}

BOOL PageLayout::GetPrintBlankPages()
{
    BOOL result;
    GetProperty(0xd, VT_BOOL, (void*)&result);
    return result;
}

void PageLayout::SetPrintBlankPages(BOOL propVal)
{
    SetProperty(0xd, VT_BOOL, propVal);
}

double PageLayout::GetWidth()
{
    double result;
    GetProperty(0xe, VT_R8, (void*)&result);
    return result;
}

void PageLayout::SetWidth(double propVal)
{
    SetProperty(0xe, VT_R8, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// PageLayout operations


/////////////////////////////////////////////////////////////////////////////
// Preferences properties

short Preferences::GetAlignToRulers()
{
    short result;
    GetProperty(0x1, VT_I2, (void*)&result);
    return result;
}

void Preferences::SetAlignToRulers(short propVal)
{
    SetProperty(0x1, VT_I2, propVal);
}

LPDISPATCH Preferences::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x2, VT_DISPATCH, (void*)&result);
    return result;
}

void Preferences::SetApplication(LPDISPATCH propVal)
{
    SetProperty(0x2, VT_DISPATCH, propVal);
}

BOOL Preferences::GetChannelAlignment()
{
    BOOL result;
    GetProperty(0x3, VT_BOOL, (void*)&result);
    return result;
}

void Preferences::SetChannelAlignment(BOOL propVal)
{
    SetProperty(0x3, VT_BOOL, propVal);
}

double Preferences::GetLineSpacingX()
{
    double result;
    GetProperty(0x4, VT_R8, (void*)&result);
    return result;
}

void Preferences::SetLineSpacingX(double propVal)
{
    SetProperty(0x4, VT_R8, propVal);
}

double Preferences::GetLineSpacingY()
{
    double result;
    GetProperty(0x5, VT_R8, (void*)&result);
    return result;
}

void Preferences::SetLineSpacingY(double propVal)
{
    SetProperty(0x5, VT_R8, propVal);
}

LPDISPATCH Preferences::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x6, VT_DISPATCH, (void*)&result);
    return result;
}

void Preferences::SetParent(LPDISPATCH propVal)
{
    SetProperty(0x6, VT_DISPATCH, propVal);
}

short Preferences::GetShapeSizing()
{
    short result;
    GetProperty(0x7, VT_I2, (void*)&result);
    return result;
}

void Preferences::SetShapeSizing(short propVal)
{
    SetProperty(0x7, VT_I2, propVal);
}

BOOL Preferences::GetShowRulers()
{
    BOOL result;
    GetProperty(0x8, VT_BOOL, (void*)&result);
    return result;
}

void Preferences::SetShowRulers(BOOL propVal)
{
    SetProperty(0x8, VT_BOOL, propVal);
}

BOOL Preferences::GetSmartShapeSpacing()
{
    BOOL result;
    GetProperty(0x9, VT_BOOL, (void*)&result);
    return result;
}

void Preferences::SetSmartShapeSpacing(BOOL propVal)
{
    SetProperty(0x9, VT_BOOL, propVal);
}

double Preferences::GetSSSHorizontal()
{
    double result;
    GetProperty(0xa, VT_R8, (void*)&result);
    return result;
}

void Preferences::SetSSSHorizontal(double propVal)
{
    SetProperty(0xa, VT_R8, propVal);
}

double Preferences::GetSSSVertical()
{
    double result;
    GetProperty(0xb, VT_R8, (void*)&result);
    return result;
}

void Preferences::SetSSSVertical(double propVal)
{
    SetProperty(0xb, VT_R8, propVal);
}

BOOL Preferences::GetTouchAlignment()
{
    BOOL result;
    GetProperty(0xc, VT_BOOL, (void*)&result);
    return result;
}

void Preferences::SetTouchAlignment(BOOL propVal)
{
    SetProperty(0xc, VT_BOOL, propVal);
}

short Preferences::GetUnits()
{
    short result;
    GetProperty(0xd, VT_I2, (void*)&result);
    return result;
}

void Preferences::SetUnits(short propVal)
{
    SetProperty(0xd, VT_I2, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// Preferences operations


/////////////////////////////////////////////////////////////////////////////
// ShapeObject properties

LPDISPATCH ShapeObject::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

void ShapeObject::SetApplication(LPDISPATCH propVal)
{
    SetProperty(0x1, VT_DISPATCH, propVal);
}

long ShapeObject::GetBorderColor()
{
    long result;
    GetProperty(0x2, VT_I4, (void*)&result);
    return result;
}

void ShapeObject::SetBorderColor(long propVal)
{
    SetProperty(0x2, VT_I4, propVal);
}

short ShapeObject::GetBorderStyle()
{
    short result;
    GetProperty(0x3, VT_I2, (void*)&result);
    return result;
}

void ShapeObject::SetBorderStyle(short propVal)
{
    SetProperty(0x3, VT_I2, propVal);
}

short ShapeObject::GetBorderWidth()
{
    short result;
    GetProperty(0x4, VT_I2, (void*)&result);
    return result;
}

void ShapeObject::SetBorderWidth(short propVal)
{
    SetProperty(0x4, VT_I2, propVal);
}

long ShapeObject::GetFillColor()
{
    long result;
    GetProperty(0x5, VT_I4, (void*)&result);
    return result;
}

void ShapeObject::SetFillColor(long propVal)
{
    SetProperty(0x5, VT_I4, propVal);
}

short ShapeObject::GetFillPattern()
{
    short result;
    GetProperty(0x6, VT_I2, (void*)&result);
    return result;
}

void ShapeObject::SetFillPattern(short propVal)
{
    SetProperty(0x6, VT_I2, propVal);
}

BOOL ShapeObject::GetIsLaunched()
{
    BOOL result;
    GetProperty(0x7, VT_BOOL, (void*)&result);
    return result;
}

void ShapeObject::SetIsLaunched(BOOL propVal)
{
    SetProperty(0x7, VT_BOOL, propVal);
}

BOOL ShapeObject::GetIsLinked()
{
    BOOL result;
    GetProperty(0x8, VT_BOOL, (void*)&result);
    return result;
}

void ShapeObject::SetIsLinked(BOOL propVal)
{
    SetProperty(0x8, VT_BOOL, propVal);
}

CString ShapeObject::GetLaunchCommand()
{
    CString result;
    GetProperty(0x9, VT_BSTR, (void*)&result);
    return result;
}

void ShapeObject::SetLaunchCommand(const char* propVal)
{
    SetProperty(0x9, VT_BSTR, propVal);
}

short ShapeObject::GetLaunchFlags()
{
    short result;
    GetProperty(0xa, VT_I2, (void*)&result);
    return result;
}

void ShapeObject::SetLaunchFlags(short propVal)
{
    SetProperty(0xa, VT_I2, propVal);
}

CString ShapeObject::GetLaunchStartDir()
{
    CString result;
    GetProperty(0xb, VT_BSTR, (void*)&result);
    return result;
}

void ShapeObject::SetLaunchStartDir(const char* propVal)
{
    SetProperty(0xb, VT_BSTR, propVal);
}

CString ShapeObject::GetLinkedChartName()
{
    CString result;
    GetProperty(0xc, VT_BSTR, (void*)&result);
    return result;
}

void ShapeObject::SetLinkedChartName(const char* propVal)
{
    SetProperty(0xc, VT_BSTR, propVal);
}

BOOL ShapeObject::GetLinkFields()
{
    BOOL result;
    GetProperty(0xd, VT_BOOL, (void*)&result);
    return result;
}

void ShapeObject::SetLinkFields(BOOL propVal)
{
    SetProperty(0xd, VT_BOOL, propVal);
}

LPDISPATCH ShapeObject::GetNoteFont()
{
    LPDISPATCH result;
    GetProperty(0xe, VT_DISPATCH, (void*)&result);
    return result;
}

void ShapeObject::SetNoteFont(LPDISPATCH propVal)
{
    SetProperty(0xe, VT_DISPATCH, propVal);
}

CString ShapeObject::GetNoteText()
{
    CString result;
    GetProperty(0xf, VT_BSTR, (void*)&result);
    return result;
}

void ShapeObject::SetNoteText(const char* propVal)
{
    SetProperty(0xf, VT_BSTR, propVal);
}

CString ShapeObject::GetNoteTextLF()
{
    CString result;
    GetProperty(0x10, VT_BSTR, (void*)&result);
    return result;
}

void ShapeObject::SetNoteTextLF(const char* propVal)
{
    SetProperty(0x10, VT_BSTR, propVal);
}

CString ShapeObject::GetNumber()
{
    CString result;
    GetProperty(0x11, VT_BSTR, (void*)&result);
    return result;
}

void ShapeObject::SetNumber(const char* propVal)
{
    SetProperty(0x11, VT_BSTR, propVal);
}

BOOL ShapeObject::GetNumberShown()
{
    BOOL result;
    GetProperty(0x12, VT_BOOL, (void*)&result);
    return result;
}

void ShapeObject::SetNumberShown(BOOL propVal)
{
    SetProperty(0x12, VT_BOOL, propVal);
}

LPDISPATCH ShapeObject::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x13, VT_DISPATCH, (void*)&result);
    return result;
}

void ShapeObject::SetParent(LPDISPATCH propVal)
{
    SetProperty(0x13, VT_DISPATCH, propVal);
}

long ShapeObject::GetShadowColor()
{
    long result;
    GetProperty(0x14, VT_I4, (void*)&result);
    return result;
}

void ShapeObject::SetShadowColor(long propVal)
{
    SetProperty(0x14, VT_I4, propVal);
}

short ShapeObject::GetShadowOffset()
{
    short result;
    GetProperty(0x15, VT_I2, (void*)&result);
    return result;
}

void ShapeObject::SetShadowOffset(short propVal)
{
    SetProperty(0x15, VT_I2, propVal);
}

short ShapeObject::GetShadowStyle()
{
    short result;
    GetProperty(0x16, VT_I2, (void*)&result);
    return result;
}

void ShapeObject::SetShadowStyle(short propVal)
{
    SetProperty(0x16, VT_I2, propVal);
}

CString ShapeObject::GetShapeName()
{
    CString result;
    GetProperty(0x17, VT_BSTR, (void*)&result);
    return result;
}

void ShapeObject::SetShapeName(const char* propVal)
{
    SetProperty(0x17, VT_BSTR, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ShapeObject operations

void ShapeObject::DeleteLines()
{
    InvokeHelper(0x18, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ShapeObject::FitShapeToText()
{
    InvokeHelper(0x19, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL ShapeObject::Launch()
{
    BOOL result;
    InvokeHelper(0x1a, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}

LPDISPATCH ShapeObject::Link()
{
    LPDISPATCH result;
    InvokeHelper(0x1b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

void ShapeObject::Renumber()
{
    InvokeHelper(0x1c, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL ShapeObject::ReplaceShape(const VARIANT& ShapeName)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x1d, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        &ShapeName);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// TextBlock properties

LPDISPATCH TextBlock::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

void TextBlock::SetApplication(LPDISPATCH propVal)
{
    SetProperty(0x1, VT_DISPATCH, propVal);
}

BOOL TextBlock::GetAttachedToLine()
{
    BOOL result;
    GetProperty(0x2, VT_BOOL, (void*)&result);
    return result;
}

void TextBlock::SetAttachedToLine(BOOL propVal)
{
    SetProperty(0x2, VT_BOOL, propVal);
}

LPDISPATCH TextBlock::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x3, VT_DISPATCH, (void*)&result);
    return result;
}

void TextBlock::SetParent(LPDISPATCH propVal)
{
    SetProperty(0x3, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// TextBlock operations

void TextBlock::UnattachFromLine()
{
    InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}